import api from './config'
import API_CONFIG from './apiConfig.js'
import logger from '../utils/logger.js'

/**
 * 创建新题目
 * @param {Object} questionData - 题目数据
 * @returns {Promise} API响应
 */
export const createQuestion = async (questionData) => {
  try {
    logger.log('🚀 [API] 开始创建题目...');
    logger.log('📝 [API] 题目数据:', questionData);
    logger.log('🌐 [API] 请求地址: /api/goc/admin/add');
    logger.log('📊 [API] 请求方法: POST');
    logger.log('📦 [API] 请求体内容:');
    console.table(questionData);
    
    const response = await api.post('/goc/admin/add', questionData);
    
    logger.log('✅ [API] 题目创建成功');
    logger.log('📄 [API] 完整响应:', response);
    logger.log('📊 [API] 响应状态码:', response?.status);
    logger.log('📦 [API] 响应数据:', response?.data);
    
    // 检查响应格式
    if (response && typeof response === 'object') {
      logger.log('📋 [API] 响应是对象类型');
      if (response.data) {
        logger.log('📦 [API] 响应包含data字段:', response.data);
      }
      if (response.status) {
        logger.log('📊 [API] HTTP状态码:', response.status);
      }
    } else {
      logger.log('⚠️ [API] 意外的响应格式:', typeof response);
    }
    
    return response;
    
  } catch (error) {
    logger.error('❌ [API] 创建题目失败:', error);
    throw error;
  }
}

/**
 * 获取共享试题列表
 * @param {Object} params - 查询参数（页码、页大小、筛选条件等）
 * @returns {Promise} API响应
 */
export const getSharedQuestionsList = async (params = {}) => {
  try {
    logger.log('🔗 [API] 获取共享试题列表...');
    logger.log('📋 [API] 查询参数:', params);
    logger.log('🌐 [API] 请求地址: /api/goc/question/shared');
    logger.log('📊 [API] 请求方法: GET');
    
    const response = await api.get('/goc/question/shared', {
      params: params
    });
    
    logger.log('✅ [API] 共享试题列表获取成功');
    logger.log('📄 [API] 完整响应:', response);
    logger.log('📊 [API] 响应状态码:', response?.status);
    logger.log('📦 [API] 响应数据:', response?.data);
    
    return response;
    
  } catch (error) {
    logger.error('❌ [API] 获取共享试题列表失败:', error);
    throw error;
  }
}

/**
 * 获取收到的共享试题列表
 * @param {Object} params - 查询参数（页码、页大小、筛选条件等）
 * @returns {Promise} API响应
 */
export const getReceivedQuestionsList = async (params = {}) => {
  try {
    logger.log('📨 [API] 获取收到的共享试题列表...');
    logger.log('📋 [API] 查询参数:', params);
    logger.log('🌐 [API] 请求地址: /api/goc/question/received');
    logger.log('📊 [API] 请求方法: GET');
    
    const response = await api.get('/goc/question/received', {
      params: params
    });
    
    logger.log('✅ [API] 收到的共享试题列表获取成功');
    logger.log('📄 [API] 完整响应:', response);
    logger.log('📊 [API] 响应状态码:', response?.status);
    logger.log('📦 [API] 响应数据:', response?.data);
    
    return response;
    
  } catch (error) {
    logger.error('❌ [API] 获取收到的共享试题列表失败:', error);
    throw error;
  }
}

/**
 * 接受共享试题
 * @param {string} questionId - 试题ID
 * @returns {Promise} API响应
 */
export const acceptSharedQuestion = async (questionId) => {
  try {
    logger.log('✅ [API] 接受共享试题...');
    logger.log('🆔 [API] 试题ID:', questionId);
    logger.log('🌐 [API] 请求地址: /api/goc/question/accept');
    logger.log('📊 [API] 请求方法: POST');
    
    const response = await api.post('/goc/question/accept', {
      questionId: questionId
    });
    
    logger.log('✅ [API] 接受共享试题成功');
    logger.log('📄 [API] 完整响应:', response);
    
    return response;
    
  } catch (error) {
    logger.error('❌ [API] 接受共享试题失败:', error);
    throw error;
  }
}

/**
 * 拒绝共享试题
 * @param {string} questionId - 试题ID
 * @returns {Promise} API响应
 */
export const rejectSharedQuestion = async (questionId) => {
  try {
    logger.log('❌ [API] 拒绝共享试题...');
    logger.log('🆔 [API] 试题ID:', questionId);
    logger.log('🌐 [API] 请求地址: /api/goc/question/reject');
    logger.log('📊 [API] 请求方法: DELETE');
    
    const response = await api.delete('/goc/question/reject', {
      params: { id: questionId }
    });
    
    logger.log('✅ [API] 拒绝共享试题成功');
    logger.log('📄 [API] 完整响应:', response);
    
    return response;
    
  } catch (error) {
    logger.error('❌ [API] 拒绝共享试题失败:', error);
    throw error;
  }
}

/**
 * 取消共享试题
 * @param {string} questionId - 试题ID
 * @returns {Promise} API响应
 */
export const unshareQuestion = async (questionId) => {
  try {
    logger.log('🚫 [API] 取消共享试题...');
    logger.log('🆔 [API] 试题ID:', questionId);
    logger.log('🌐 [API] 请求地址: /api/goc/question/unshare');
    logger.log('📊 [API] 请求方法: DELETE');
    
    const response = await api.delete('/goc/question/unshare', {
      params: { id: questionId }
    });
    
    logger.log('✅ [API] 取消共享成功');
    logger.log('📄 [API] 完整响应:', response);
    
    return response;
    
  } catch (error) {
    logger.error('❌ [API] 取消共享失败:', error);
    throw error;
  }
}

/**
 * 获取题目列表
 * @param {Object} params - 查询参数
 * @returns {Promise} API响应
 */
export const getQuestionList = async (params = {}) => {
  try {
    logger.log('🔍 [API] 获取题目列表...');
    logger.log('📊 [API] 查询参数:', params);
    
    const response = await api.get('/goc/testQuestion/list', { params });
    
    logger.log('✅ [API] 题目列表获取成功:', response);
    return response;
    
  } catch (error) {
    logger.error('❌ [API] 获取题目列表失败:', error);
    throw error;
  }
}

/**
 * 根据ID获取题目详情 (通过list接口的keyword参数查询)
 * @param {String|Number} questionId - 题目ID
 * @returns {Promise} API响应
 */
export const getQuestionById = async (questionId) => {
  try {
    logger.log('🔍 [API] ==================== 开始获取题目详情 ====================');
    logger.log('🆔 [API] 题目ID:', questionId);
    logger.log('🆔 [API] ID类型:', typeof questionId);
    
    // 优先尝试使用list接口通过keyword参数查询
    try {
      logger.log('🌐 [API] ==================== 步骤1: 尝试LIST接口 ====================');
      
      // 首先尝试从本地存储获取题目信息构建关键词
      let keyword = String(questionId); // 默认使用ID作为降级方案
      logger.log('🏠 [API] 尝试从本地存储获取题目信息...');
      logger.log('🏠 [API] 查询ID:', questionId);
      
      try {
        const { default: localQuestionStorage } = await import('@/utils/localStorage');
        logger.log('🏠 [API] 本地存储模块已加载');
        const localQuestion = localQuestionStorage.getQuestionById(questionId);
        logger.log('🏠 [API] 本地查询结果:', localQuestion ? '找到题目' : '未找到题目');
        
                  if (localQuestion) {
            logger.log('📋 [API] 本地题目信息:', localQuestion);
            logger.log('📋 [API] 本地题目ID:', localQuestion.id, typeof localQuestion.id);
            logger.log('📋 [API] 本地题目名称:', localQuestion.questionName);
            logger.log('📋 [API] 本地题目来源:', localQuestion.source);
            // 构建关键词：仅使用题目名称（后端要求）
            const questionName = localQuestion.questionName || localQuestion.name || '';
            
            if (questionName) {
              keyword = questionName.trim();
              logger.log('📝 [API] 使用题目名称:', keyword);
            } else {
              logger.log('🆔 [API] 降级使用ID:', keyword);
            }
          } else {
            logger.log('⚠️ [API] 未找到本地题目，降级使用ID:', keyword);
          }
      } catch (localError) {
        logger.warn('⚠️ [API] 获取本地题目信息失败，降级使用ID:', localError);
      }
      
      const listParams = {
        keyword: keyword // 使用关键词+ID或纯ID
      };
      logger.log('📊 [API] 查询参数:', listParams);
      
      logger.log('🚀 [API] 即将调用list接口...');
      logger.log('🚀 [API] 接口地址: /api/goc/testQuestion/list');
      logger.log('🚀 [API] 请求参数:', listParams);
      
      const response = await api.get('/goc/testQuestion/list', { params: listParams });
      
      logger.log('✅ [API] list接口调用成功!');
      logger.log('📄 [API] list接口响应:', response);
      logger.log('📊 [API] 响应状态码:', response?.status);
      logger.log('📦 [API] 响应数据:', response?.data);
      
      // 从列表中找到匹配的题目
      if (response && response.data && response.data.records && Array.isArray(response.data.records)) {
        const questions = response.data.records;
        logger.log('📋 [API] 找到题目列表，数量:', questions.length);
        logger.log('📋 [API] 题目列表详情:', questions.map(q => ({ id: q.id, name: q.questionName })));
        
        // 查找匹配的题目 (优先基于关键词匹配，因为ID可能不一致)
        const targetQuestion = questions.find(q => {
          logger.log('🔍 [API] 检查题目匹配:', { 
            questionId: q.id, 
            targetId: questionId, 
            questionName: q.questionName,
            keyword: keyword 
          });
          
          // 优先策略：如果使用关键词搜索且只返回一个结果，直接使用第一个
          if (questions.length === 1) {
            logger.log('✅ [API] 唯一搜索结果匹配 (只有1个结果)');
            logger.log('🔍 [API] 关键词:', keyword, '题目ID:', questionId);
            return true;
          }
          
          const qId = String(q.id);
          const searchId = String(questionId);
          
          // 精确匹配
          if (qId === searchId) {
            logger.log('✅ [API] 精确匹配成功');
            return true;
          }
          
          // 数字匹配
          if (Number(qId) === Number(searchId)) {
            logger.log('✅ [API] 数字匹配成功');
            return true;
          }
          
          // 题目名称匹配（如果有关键词）
          if (keyword && q.questionName && q.questionName.includes(keyword)) {
            logger.log('✅ [API] 题目名称匹配成功');
            return true;
          }
          
          // 长ID匹配短ID (取最后几位)
          if (searchId.length > 3) {
            const numericPart = searchId.replace(/\D/g, '');
            if (numericPart.length >= 3) {
              const shortId = parseInt(numericPart.slice(-4));
              if (Number(qId) === shortId) {
                logger.log('✅ [API] 短ID匹配成功');
                return true;
              }
            }
          }
          
          // 反向匹配：如果返回的ID是长ID，而搜索的是短ID
          if (qId.length > searchId.length) {
            const qNumericPart = qId.replace(/\D/g, '');
            if (qNumericPart.includes(searchId)) {
              logger.log('✅ [API] 反向匹配成功');
              return true;
            }
          }
          
          return false;
        });
        
        if (targetQuestion) {
          logger.log('✅ [API] 通过list接口找到目标题目:', targetQuestion);
          return { data: targetQuestion };
        } else {
          logger.warn('⚠️ [API] list接口未找到匹配的题目');
          throw new Error('题目未找到');
        }
      } else {
        logger.warn('⚠️ [API] list接口响应格式异常');
        throw new Error('响应格式异常');
      }
    } catch (listError) {
      logger.error('💥 [API] ==================== LIST接口失败 ====================');
      logger.error('💥 [API] 错误详情:', listError);
      logger.error('💥 [API] 错误堆栈:', listError.stack);
      logger.warn('⚠️ [API] list接口查询失败，尝试传统单题接口:', listError);
      
      // 备用方案：使用传统的单题接口
      logger.log('🔄 [API] ==================== 步骤2: 尝试传统接口 ====================');
      const response = await api.get(`/api/goc/testQuestion/${questionId}`);
      logger.log('📄 [API] 传统接口响应:', response);
      
      // 检查传统接口的响应
      if (response && response.data && response.data !== null && (response.code === 0 || !Object.prototype.hasOwnProperty.call(response, 'code'))) {
        logger.log('✅ [API] 传统接口题目详情获取成功:', response);
        return response;
      } else {
        logger.error('❌ [API] 传统接口也返回了错误或空数据:', response);
        throw new Error(`传统接口失败: ${response.message || '数据为空'}`);
      }
    }
    
  } catch (error) {
    logger.error('❌ [API] 获取题目详情失败:', error);
    throw error;
  }
}

/**
 * 更新题目信息（普通用户接口）
 * @param {String|Number} questionId - 题目ID
 * @param {Object} questionData - 更新的题目数据
 * @returns {Promise} API响应
 */
export const updateQuestion = async (questionId, questionData) => {
  try {
    logger.log('🔄 [API] 更新题目信息...');
    logger.log('🆔 [API] 题目ID:', questionId);
    logger.log('📝 [API] 更新数据:', questionData);
    
    const response = await api.put(`/api/goc/testQuestion/${questionId}`, questionData);
    
    logger.log('✅ [API] 题目更新成功:', response);
    return response;
    
  } catch (error) {
    logger.error('❌ [API] 更新题目失败:', error);
    throw error;
  }
}

/**
 * 管理员更新试题信息
 * @param {Object} questionData - 完整的试题数据（包含ID等所有字段）
 * @returns {Promise} API响应
 */
export const adminUpdateQuestion = async (questionData) => {
  try {
    logger.log('🔄 [API] 管理员更新试题信息...');
    logger.log('📝 [API] 试题数据:', questionData);
    logger.log('🌐 [API] 请求地址: /api/goc/admin/update');
    logger.log('📊 [API] 请求方法: PUT');
    logger.log('📦 [API] 请求体内容:');
    console.table(questionData);
    
    // 构建完整URL用于调试
    const baseURL = api.defaults.baseURL || API_CONFIG.BASE_URL;
    const fullURL = `${baseURL}${API_CONFIG.ENDPOINTS.ADMIN_UPDATE}`;
    logger.log('🌐 [API] 完整请求URL:', fullURL);
    
    const response = await api.put('/goc/admin/update', questionData);
    
    logger.log('✅ [API] 管理员试题更新成功');
    logger.log('📄 [API] 完整响应:', response);
    logger.log('📊 [API] 响应状态码:', response?.status);
    logger.log('📦 [API] 响应数据:', response?.data);
    
    // 检查响应格式
    if (response && typeof response === 'object') {
      logger.log('📋 [API] 响应是对象类型');
      if (response.data) {
        logger.log('📦 [API] 响应包含data字段:', response.data);
      }
      if (response.code !== undefined) {
        logger.log('📊 [API] 业务状态码:', response.code);
      }
      if (response.message) {
        logger.log('💬 [API] 响应消息:', response.message);
      }
    } else {
      logger.log('⚠️ [API] 意外的响应格式:', typeof response);
    }
    
    return response;
    
  } catch (error) {
    logger.error('❌ [API] 管理员更新试题失败:', error);
    logger.error('❌ [API] 错误详情:', {
      message: error.message,
      status: error.response?.status,
      statusText: error.response?.statusText,
      data: error.response?.data,
      url: error.config?.url,
      method: error.config?.method
    });
    throw error;
  }
}

/**
 * 删除题目
 * @param {String|Number} questionId - 题目ID（使用后端返回的真实ID）
 * @returns {Promise} API响应
 */
export const deleteQuestion = async (questionId) => {
  try {
    logger.log('🗑️ [API] 删除题目...');
    logger.log('🆔 [API] 题目ID:', questionId);
    logger.log('🆔 [API] ID类型:', typeof questionId);
    
    // 构建完整URL用于调试
    const baseURL = api.defaults.baseURL || API_CONFIG.BASE_URL;
    const fullURL = `${baseURL}${API_CONFIG.ENDPOINTS.ADMIN_DELETE}?id=${questionId}`;
    logger.log('🌐 [API] 完整删除URL:', fullURL);
    logger.log('🔗 [API] 删除接口: DELETE /api/goc/admin/delete');
    
    // 调用DELETE接口，使用Query参数传递ID
    const response = await api.delete('/goc/admin/delete', {
      params: {
        id: questionId
      }
    });
    
    logger.log('✅ [API] 删除题目响应:', response);
    logger.log('📊 [API] 响应状态码:', response?.status);
    logger.log('📦 [API] 响应数据:', response?.data);
    logger.log('🔍 [API] 响应代码:', response?.code);
    logger.log('💬 [API] 响应消息:', response?.message);
    
    return response;
    
  } catch (error) {
    logger.error('❌ [API] 删除题目失败:', error);
    logger.error('❌ [API] 错误详情:', {
      message: error.message,
      status: error.response?.status,
      statusText: error.response?.statusText,
      data: error.response?.data,
      url: error.config?.url,
      method: error.config?.method,
      params: error.config?.params
    });
    throw error;
  }
}

/**
 * 搜索题目 (使用search接口)
 * @param {Object} searchParams - 搜索参数
 * @returns {Promise} API响应
 */
export const searchQuestions = async (searchParams) => {
  try {
    logger.log('🔍 [API] 搜索题目...');
    logger.log('🔎 [API] 搜索参数:', searchParams);
    
    const response = await api.get('/goc/testQuestion/search', { params: searchParams });
    
    logger.log('✅ [API] 题目搜索成功:', response);
    return response;
    
  } catch (error) {
    logger.error('❌ [API] 搜索题目失败:', error);
    throw error;
  }
}

/**
 * 通过关键词搜索题目 (使用list接口的keyword参数)
 * @param {String|Number} questionIdOrKeyword - 题目ID或自定义关键词
 * @param {Object} additionalParams - 其他查询参数
 * @param {Boolean} autoAddId - 是否自动添加ID到关键词后面
 * @returns {Promise} API响应
 */
export const searchQuestionsByKeyword = async (questionIdOrKeyword, additionalParams = {}, autoGenerateKeyword = false) => {
  try {
    logger.log('🔍 [API] 通过关键词搜索题目...');
    logger.log('🔎 [API] 输入参数:', questionIdOrKeyword);
    logger.log('📊 [API] 附加参数:', additionalParams);
    logger.log('🏷️ [API] 自动生成关键词:', autoGenerateKeyword);
    
    let keyword = String(questionIdOrKeyword);
    
    // 如果需要自动生成关键词（仅使用题目名称）
    if (autoGenerateKeyword && typeof questionIdOrKeyword === 'number') {
      try {
        const { default: localQuestionStorage } = await import('@/utils/localStorage');
        const localQuestion = localQuestionStorage.getQuestionById(questionIdOrKeyword);
        
        if (localQuestion) {
          const questionName = localQuestion.questionName || '';
          
          if (questionName) {
            keyword = questionName.trim();
            logger.log('📝 [API] 自动生成题目名称:', keyword);
          }
        }
      } catch (localError) {
        logger.warn('⚠️ [API] 获取本地题目信息失败，使用原始关键词:', localError);
      }
    }
    
    const params = {
      keyword: keyword,
      ...additionalParams
    };
    
    logger.log('📋 [API] 最终查询参数:', params);
    
    const response = await api.get('/goc/testQuestion/list', { params });
    
    logger.log('✅ [API] 关键词搜索成功:', response);
    logger.log('📄 [API] 搜索结果数量:', response?.data?.records?.length || 0);
    
    return response;
    
  } catch (error) {
    logger.error('❌ [API] 关键词搜索失败:', error);
    throw error;
  }
}

/**
 * 通过题目数据搜索 (直接使用已知的题目信息构建关键词)
 * @param {Object} questionData - 题目数据对象
 * @returns {Promise} API响应
 */
export const searchQuestionByData = async (questionData) => {
  try {
    logger.log('🔍 [API] 通过题目数据搜索...');
    logger.log('📋 [API] 题目数据:', questionData);
    
    // 构建关键词：仅使用题目名称（后端要求）
    let keyword = String(questionData.id || ''); // 降级方案
    
    const questionName = questionData.questionName || '';
    
    if (questionName) {
      // 仅使用题目名称（后端要求）
      keyword = questionName.trim();
      logger.log('📝 [API] 使用题目名称:', keyword);
    } else {
      logger.log('🆔 [API] 降级使用ID作为关键词:', keyword);
    }
    
    const params = {
      keyword: keyword
    };
    
    logger.log('📊 [API] 查询参数:', params);
    
    const response = await api.get('/goc/testQuestion/list', { params });
    
    logger.log('✅ [API] 题目数据搜索成功:', response);
    logger.log('📄 [API] 搜索结果数量:', response?.data?.records?.length || 0);
    
    return response;
    
  } catch (error) {
    logger.error('❌ [API] 题目数据搜索失败:', error);
    throw error;
  }
}

/**
 * 获取题目统计信息
 * @returns {Promise} API响应
 */
export const getQuestionStats = async () => {
  try {
    logger.log('📊 [API] 获取题目统计信息...');
    
    const response = await api.get('/goc/testQuestion/stats');
    
    logger.log('✅ [API] 题目统计获取成功:', response);
    return response;
    
  } catch (error) {
    logger.error('❌ [API] 获取题目统计失败:', error);
    throw error;
  }
}

/**
 * 获取我创建的题目列表（优先使用专门的用户题目接口）
 * @param {Object} params - 查询参数（包含分页、搜索条件等）
 * @returns {Promise} API响应
 */
export const getMyQuestions = async (params = {}) => {
  try {
    logger.log('👤 [API] 获取我创建的题目列表...');
    logger.log('📊 [API] 查询参数:', params);
    
    // 尝试专门的"我的题目"接口，如果失败则使用备选方案
    let response;
    try {
      // 首先尝试用户创建的题目专用接口
      logger.log('🔄 [API] 尝试我的题目专用接口: /api/goc/user/myQuestions');
      response = await api.get('/goc/user/myQuestions', { params });
    } catch (firstError) {
      logger.log('⚠️ [API] 专用接口不存在，尝试用户题目管理接口: /api/goc/user/questions');
      try {
        response = await api.get('/goc/user/questions', { params });
      } catch (secondError) {
        logger.log('⚠️ [API] 管理接口不存在，使用通用接口但仅通过createUserId过滤');
        response = await api.get('/goc/testQuestion/list', { params });
      }
    }
    
    logger.log('✅ [API] 我的题目列表获取成功');
    logger.log('📄 [API] 完整响应:', response);
    logger.log('📊 [API] 响应状态码:', response?.status);
    logger.log('📦 [API] 响应数据:', response?.data);
    
    return response;
    
  } catch (error) {
    logger.error('❌ [API] 获取我的题目列表失败:', error);
    logger.error('❌ [API] 错误详情:', {
      message: error.message,
      status: error.response?.status,
      data: error.response?.data
    });
    throw error;
  }
} 